// Generated from SyntaxParser.g4 by ANTLR 4.13.2
package ling.learn.antlr.syntax.gen;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue", "this-escape"})
public class SyntaxParser extends Parser {
	static { RuntimeMetaData.checkVersion("4.13.2", RuntimeMetaData.VERSION); }

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		KW_ACCEPT=1, KW_ACCESS=2, KW_ADD=3, KW_ADDRESS=4, KW_ADVANCING=5, KW_AFTER=6, 
		KW_ASCENDING=7, KW_ALL=8, KW_ALLOCATE=9, KW_ALPHABET=10, KW_ALPHABETIC=11, 
		KW_ALPHABETIC_LOWER=12, KW_ALPHABETIC_UPPER=13, KW_ALSO=14, KW_ALTER=15, 
		KW_ALTERNATE=16, KW_AND=17, KW_ANY=18, KW_APPLY=19, KW_ARE=20, KW_AREA=21, 
		KW_AREAS=22, KW_ASSIGN=23, KW_AS=24, KW_AT=25, KW_ATTRIBUTE=26, KW_ATTRIBUTES=27, 
		KW_BEFORE=28, KW_BINARY=29, KW_BLANK=30, KW_BLOCK=31, KW_BOOL=32, KW_BOOLEAN=33, 
		KW_BOTTOM=34, KW_BY=35, KW_BYTE_LENGTH=36, KW_CALL=37, KW_CANCEL=38, KW_CHARACTER=39, 
		KW_CHARACTERS=40, KW_CICS=41, KW_CLASS=42, KW_CLASS_ID=43, KW_CLOSE=44, 
		KW_COBOL=45, KW_CODE_SET=46, KW_COLLATING=47, KW_COMMA=48, KW_COMMON=49, 
		KW_COMP=50, KW_COMP_1=51, KW_COMP_2=52, KW_COMP_3=53, KW_COMP_4=54, KW_COMP_5=55, 
		KW_COMPUTATIONAL=56, KW_COMPUTATIONAL_1=57, KW_COMPUTATIONAL_2=58, KW_COMPUTATIONAL_3=59, 
		KW_COMPUTATIONAL_4=60, KW_COMPUTATIONAL_5=61, KW_COMPUTE=62, KW_CONFIGURATION=63, 
		KW_CONTAINS=64, KW_CONTENT=65, KW_CONTINUE=66, KW_CONVERTING=67, KW_CORR=68, 
		KW_CORRESPONDING=69, KW_COUNT=70, KW_CURRENCY=71, KW_CYCLE=72, KW_DATA=73, 
		KW_DATE=74, KW_DAY=75, KW_DAY_OF_WEEK=76, KW_DBCS=77, KW_DEBUGGING=78, 
		KW_DECIMAL_POINT=79, KW_DECLARATIVE=80, KW_DECLARATIVES=81, KW_DEFAULT=82, 
		KW_DELETE=83, KW_DELIMITED=84, KW_DELIMITER=85, KW_DEPENDING=86, KW_DESCENDING=87, 
		KW_DETAIL=88, KW_DISPLAY=89, KW_DISPLAY_1=90, KW_DIVIDE=91, KW_DIVISION=92, 
		KW_DOWN=93, KW_DUPLICATES=94, KW_DYNAMIC=95, KW_EBCDIC=96, KW_ELEMENT=97, 
		KW_ELSE=98, KW_END=99, KW_END_ADD=100, KW_END_CALL=101, KW_END_COMPUTE=102, 
		KW_END_DELETE=103, KW_END_DIVIDE=104, KW_END_EVALUATE=105, KW_END_EXEC=106, 
		KW_END_IF=107, KW_END_INVOKE=108, KW_END_JSON=109, KW_END_MULTIPLY=110, 
		KW_END_OF_PAGE=111, KW_END_PERFORM=112, KW_END_READ=113, KW_END_RETURN=114, 
		KW_END_REWRITE=115, KW_END_SEARCH=116, KW_END_START=117, KW_END_STRING=118, 
		KW_END_SUBTRACT=119, KW_END_UNSTRING=120, KW_END_WRITE=121, KW_END_XML=122, 
		KW_ENTRY=123, KW_ENVIRONMENT=124, KW_EQUAL=125, KW_EOP=126, KW_ERROR=127, 
		KW_EVALUATE=128, KW_EVERY=129, KW_EXCEPTION=130, KW_EXEC=131, KW_EXIT=132, 
		KW_EXTEND=133, KW_EXTERNAL=134, KW_FACTORY=135, KW_FALSE=136, KW_FD=137, 
		KW_FILE=138, KW_FILE_CONTROL=139, KW_FILLER=140, KW_FIRST=141, KW_FIXED=142, 
		KW_FOR=143, KW_FOOTING=144, KW_FREE=145, KW_FROM=146, KW_FUNCTION=147, 
		KW_FUNCTION_POINTER=148, KW_GENERATE=149, KW_GLOBAL=150, KW_GIVING=151, 
		KW_GO=152, KW_GOBACK=153, KW_GREATER=154, KW_GROUP_USAGE=155, KW_HIGH_VALUE=156, 
		KW_HIGH_VALUES=157, KW_ID=158, KW_IDENTIFICATION=159, KW_IF=160, KW_IN=161, 
		KW_INDEX=162, KW_INDEXED=163, KW_INHERITS=164, KW_INITIAL=165, KW_INITIALIZE=166, 
		KW_INITIALIZED=167, KW_INPUT=168, KW_INPUT_OUTPUT=169, KW_INSPECT=170, 
		KW_INTO=171, KW_INTRINSIC=172, KW_INVALID=173, KW_INVOKE=174, KW_I_O=175, 
		KW_I_O_CONTROL=176, KW_IS=177, KW_JSON=178, KW_JUST=179, KW_JUSTIFIED=180, 
		KW_KANJI=181, KW_KEY=182, KW_LABEL=183, KW_LEADING=184, KW_LEFT=185, KW_LENGTH=186, 
		KW_LESS=187, KW_LIMIT=188, KW_LINAGE=189, KW_LINE=190, KW_LINES=191, KW_LINKAGE=192, 
		KW_LOC=193, KW_LOCK=194, KW_LOCAL_STORAGE=195, KW_LOW_VALUE=196, KW_LOW_VALUES=197, 
		KW_MEMORY=198, KW_MERGE=199, KW_METHOD=200, KW_METHOD_ID=201, KW_MODE=202, 
		KW_MODULES=203, KW_MOVE=204, KW_MULTIPLE=205, KW_MULTIPLY=206, KW_NAME=207, 
		KW_NAMESPACE=208, KW_NAMESPACE_PREFIX=209, KW_NATIVE=210, KW_NATIONAL=211, 
		KW_NEGATIVE=212, KW_NEW=213, KW_NEXT=214, KW_NO=215, KW_NOT=216, KW_NUMERIC=217, 
		KW_NONNUMERIC=218, KW_NULL=219, KW_NULLS=220, KW_OBJECT=221, KW_OBJECT_COMPUTER=222, 
		KW_OCCURS=223, KW_OUTPUT=224, KW_OF=225, KW_OFF=226, KW_ON=227, KW_OMITTED=228, 
		KW_OPEN=229, KW_OR=230, KW_ORDER=231, KW_ORGANIZATION=232, KW_OPTIONAL=233, 
		KW_OTHER=234, KW_OVERFLOW=235, KW_PACKED_DECIMAL=236, KW_PADDING=237, 
		KW_PAGE=238, KW_PARAGRAPH=239, KW_PARSE=240, KW_PASSWORD=241, KW_PERFORM=242, 
		KW_PIC=243, KW_PICTURE=244, KW_POINTER=245, KW_POINTER_32=246, KW_POSITION=247, 
		KW_POSITIVE=248, KW_PROCEDURE=249, KW_PROCEDURE_POINTER=250, KW_PROCEDURES=251, 
		KW_PROCEED=252, KW_PROCESSING=253, KW_PROGRAM=254, KW_PROGRAM_ID=255, 
		KW_QUOTE=256, KW_QUOTES=257, KW_RANDOM=258, KW_READ=259, KW_RECORD=260, 
		KW_RECORDING=261, KW_RECORDS=262, KW_RECURSIVE=263, KW_REDEFINES=264, 
		KW_REEL=265, KW_REFERENCE=266, KW_RELATIVE=267, KW_RELEASE=268, KW_REMAINDER=269, 
		KW_REMOVAL=270, KW_RENAMES=271, KW_RERUN=272, KW_RETURN=273, KW_REPLACING=274, 
		KW_REPOSITORY=275, KW_RESERVE=276, KW_RETURNING=277, KW_REVERSED=278, 
		KW_REWIND=279, KW_REWRITE=280, KW_RIGHT=281, KW_ROUNDED=282, KW_RUN=283, 
		KW_SD=284, KW_SAME=285, KW_SEARCH=286, KW_SECTION=287, KW_SEGMENT_LIMIT=288, 
		KW_SELECT=289, KW_SELF=290, KW_SENTENCE=291, KW_SEPARATE=292, KW_SEQUENCE=293, 
		KW_SEQUENTIAL=294, KW_SET=295, KW_SIGN=296, KW_SIZE=297, KW_SORT=298, 
		KW_SORT_MERGE=299, KW_SOURCE_COMPUTER=300, KW_SPACE=301, KW_SPACES=302, 
		KW_SPECIAL_NAMES=303, KW_SQL=304, KW_SQLIMS=305, KW_STANDARD=306, KW_STANDARD_1=307, 
		KW_STANDARD_2=308, KW_START=309, KW_STATUS=310, KW_STOP=311, KW_STRING=312, 
		KW_SUBTRACT=313, KW_SUPER=314, KW_SUPPRESS=315, KW_SYMBOL=316, KW_SYMBOLIC=317, 
		KW_SYNC=318, KW_SYNCHRONIZED=319, KW_TALLYING=320, KW_TAPE=321, KW_TEST=322, 
		KW_THAN=323, KW_THEN=324, KW_THROUGH=325, KW_THRU=326, KW_TIME=327, KW_TIMES=328, 
		KW_TO=329, KW_TOP=330, KW_TRAILING=331, KW_TRUE=332, KW_TYPE=333, KW_UNIT=334, 
		KW_UNBOUNDED=335, KW_UNTIL=336, KW_UNSTRING=337, KW_UP=338, KW_UPON=339, 
		KW_USAGE=340, KW_USE=341, KW_USING=342, KW_UTF_8=343, KW_VALIDATING=344, 
		KW_VALUE=345, KW_VALUES=346, KW_VARYING=347, KW_VOLATILE=348, KW_WHEN=349, 
		KW_WITH=350, KW_WRITE=351, KW_WRITE_ONLY=352, KW_WORDS=353, KW_WORKING_STORAGE=354, 
		KW_XML=355, KW_XML_DECLARATION=356, KW_XML_SCHEMA=357, KW_YYYYDDD=358, 
		KW_YYYYMMDD=359, KW_ZERO=360, KW_ZEROES=361, KW_ZEROS=362, PLUS=363, MINUS=364, 
		STAR=365, SLASH=366, ASSIGN=367, COMMA=368, SEMI=369, COLON=370, EQUAL=371, 
		NOT_EQUAL=372, LT=373, LE=374, GE=375, GT=376, LPAREN=377, RPAREN=378, 
		LBRACK=379, LBRACK2=380, RBRACK=381, RBRACK2=382, POINTER2=383, AT2=384, 
		DOT=385, DOTDOT=386, LCURLY=387, RCURLY=388, AMBER=389, DOUBLEAT=390, 
		DOLLAR=391, StringLiteral=392, DbcsLiteral=393, Utf8Literal=394, HexNumber=395, 
		NullTerminated=396, IntegerLiteral=397, DecimalLiteral=398, Identifier=399, 
		EOL=400, WS=401, UnicodeBOM=402, PicString=403, PicWS=404, ANY=405;
	public static final int
		RULE_file = 0, RULE_dataDescription = 1, RULE_levelNum = 2, RULE_データ名 = 3, 
		RULE_execStmt = 4, RULE_line = 5, RULE_wordList = 6, RULE_word = 7, RULE_literal = 8, 
		RULE_numericLiteral = 9, RULE_nonnumericLiteral = 10, RULE_keyword = 11;
	private static String[] makeRuleNames() {
		return new String[] {
			"file", "dataDescription", "levelNum", "データ名", "execStmt", "line", "wordList", 
			"word", "literal", "numericLiteral", "nonnumericLiteral", "keyword"
		};
	}
	public static final String[] ruleNames = makeRuleNames();

	private static String[] makeLiteralNames() {
		return new String[] {
			null, "'ACCEPT'", "'ACCESS'", "'ADD'", "'ADDRESS'", "'ADVANCING'", "'AFTER'", 
			"'ASCENDING'", "'ALL'", "'ALLOCATE'", "'ALPHABET'", "'ALPHABETIC'", "'ALPHABETIC-LOWER'", 
			"'ALPHABETIC-UPPER'", "'ALSO'", "'ALTER'", "'ALTERNATE'", "'AND'", "'ANY'", 
			"'APPLY'", "'ARE'", "'AREA'", "'AREAS'", "'ASSIGN'", "'AS'", "'AT'", 
			"'ATTRIBUTE'", "'ATTRIBUTES'", "'BEFORE'", "'BINARY'", "'BLANK'", "'BLOCK'", 
			"'BOOL'", "'BOOLEAN'", "'BOTTOM'", "'BY'", "'BYTE-LENGTH'", "'CALL'", 
			"'CANCEL'", "'CHARACTER'", "'CHARACTERS'", "'CICS'", "'CLASS'", "'CLASS-ID'", 
			"'CLOSE'", "'COBOL'", "'CODE-SET'", "'COLLATING'", "'COMMA'", "'COMMON'", 
			"'COMP'", "'COMP-1'", "'COMP-2'", "'COMP-3'", "'COMP-4'", "'COMP-5'", 
			"'COMPUTATIONAL'", "'COMPUTATIONAL-1'", "'COMPUTATIONAL-2'", "'COMPUTATIONAL-3'", 
			"'COMPUTATIONAL-4'", "'COMPUTATIONAL-5'", "'COMPUTE'", "'CONFIGURATION'", 
			"'CONTAINS'", "'CONTENT'", "'CONTINUE'", "'CONVERTING'", "'CORR'", "'CORRESPONDING'", 
			"'COUNT'", "'CURRENCY'", "'CYCLE'", "'DATA'", "'DATE'", "'DAY'", "'DAY-OF-WEEK'", 
			"'DBCS'", "'DEBUGGING'", "'DECIMAL-POINT'", "'DECLARATIVE'", "'DECLARATIVES'", 
			"'DEFAULT'", "'DELETE'", "'DELIMITED'", "'DELIMITER'", "'DEPENDING'", 
			"'DESCENDING'", "'DETAIL'", "'DISPLAY'", "'DISPLAY-1'", "'DIVIDE'", "'DIVISION'", 
			"'DOWN'", "'DUPLICATES'", "'DYNAMIC'", "'EBCDIC'", "'ELEMENT'", "'ELSE'", 
			"'END'", "'END-ADD'", "'END-CALL'", "'END-COMPUTE'", "'END-DELETE'", 
			"'END-DIVIDE'", "'END-EVALUATE'", "'END-EXEC'", "'END-IF'", "'END-INVOKE'", 
			"'END-JSON'", "'END-MULTIPLY'", "'END-OF-PAGE'", "'END-PERFORM'", "'END-READ'", 
			"'END-RETURN'", "'END-REWRITE'", "'END-SEARCH'", "'END-START'", "'END-STRING'", 
			"'END-SUBTRACT'", "'END-UNSTRING'", "'END-WRITE'", "'END-XML'", "'ENTRY'", 
			"'ENVIRONMENT'", "'EQUAL'", "'EOP'", "'ERROR'", "'EVALUATE'", "'EVERY'", 
			"'EXCEPTION'", "'EXEC'", "'EXIT'", "'EXTEND'", "'EXTERNAL'", "'FACTORY'", 
			"'FALSE'", "'FD'", "'FILE'", "'FILE-CONTROL'", "'FILLER'", "'FIRST'", 
			"'FIXED'", "'FOR'", "'FOOTING'", "'FREE'", "'FROM'", "'FUNCTION'", "'FUNCTION-POINTER'", 
			"'GENERATE'", "'GLOBAL'", "'GIVING'", "'GO'", "'GOBACK'", "'GREATER'", 
			"'GROUP-USAGE'", "'HIGH-VALUE'", "'HIGH-VALUES'", "'ID'", "'IDENTIFICATION'", 
			"'IF'", "'IN'", "'INDEX'", "'INDEXED'", "'INHERITS'", "'INITIAL'", "'INITIALIZE'", 
			"'INITIALIZED'", "'INPUT'", "'INPUT-OUTPUT'", "'INSPECT'", "'INTO'", 
			"'INTRINSIC'", "'INVALID'", "'INVOKE'", "'I-O'", "'I-O-CONTROL'", "'IS'", 
			"'JSON'", "'JUST'", "'JUSTIFIED'", "'KANJI'", "'KEY'", "'LABEL'", "'LEADING'", 
			"'LEFT'", "'LENGTH'", "'LESS'", "'LIMIT'", "'LINAGE'", "'LINE'", "'LINES'", 
			"'LINKAGE'", "'LOC'", "'LOCK'", "'LOCAL-STORAGE'", "'LOW-VALUE'", "'LOW-VALUES'", 
			"'MEMORY'", "'MERGE'", "'METHOD'", "'METHOD-ID'", "'MODE'", "'MODULES'", 
			"'MOVE'", "'MULTIPLE'", "'MULTIPLY'", "'NAME'", "'NAMESPACE'", "'NAMESPACE-PREFIX'", 
			"'NATIVE'", "'NATIONAL'", "'NEGATIVE'", "'NEW'", "'NEXT'", "'NO'", "'NOT'", 
			"'NUMERIC'", "'NONNUMERIC'", "'NULL'", "'NULLS'", "'OBJECT'", "'OBJECT-COMPUTER'", 
			"'OCCURS'", "'OUTPUT'", "'OF'", "'OFF'", "'ON'", "'OMITTED'", "'OPEN'", 
			"'OR'", "'ORDER'", "'ORGANIZATION'", "'OPTIONAL'", "'OTHER'", "'OVERFLOW'", 
			"'PACKED-DECIMAL'", "'PADDING'", "'PAGE'", "'PARAGRAPH'", "'PARSE'", 
			"'PASSWORD'", "'PERFORM'", "'PIC'", "'PICTURE'", "'POINTER'", "'POINTER-32'", 
			"'POSITION'", "'POSITIVE'", "'PROCEDURE'", "'PROCEDURE-POINTER'", "'PROCEDURES'", 
			"'PROCEED'", "'PROCESSING'", "'PROGRAM'", "'PROGRAM-ID'", "'QUOTE'", 
			"'QUOTES'", "'RANDOM'", "'READ'", "'RECORD'", "'RECORDING'", "'RECORDS'", 
			"'RECURSIVE'", "'REDEFINES'", "'REEL'", "'REFERENCE'", "'RELATIVE'", 
			"'RELEASE'", "'REMAINDER'", "'REMOVAL'", "'RENAMES'", "'RERUN'", "'RETURN'", 
			"'REPLACING'", "'REPOSITORY'", "'RESERVE'", "'RETURNING'", "'REVERSED'", 
			"'REWIND'", "'REWRITE'", "'RIGHT'", "'ROUNDED'", "'RUN'", "'SD'", "'SAME'", 
			"'SEARCH'", "'SECTION'", "'SEGMENT-LIMIT'", "'SELECT'", "'SELF'", "'SENTENCE'", 
			"'SEPARATE'", "'SEQUENCE'", "'SEQUENTIAL'", "'SET'", "'SIGN'", "'SIZE'", 
			"'SORT'", "'SORT-MERGE'", "'SOURCE-COMPUTER'", "'SPACE'", "'SPACES'", 
			"'SPECIAL-NAMES'", "'SQL'", "'SQLIMS'", "'STANDARD'", "'STANDARD-1'", 
			"'STANDARD-2'", "'START'", "'STATUS'", "'STOP'", "'STRING'", "'SUBTRACT'", 
			"'SUPER'", "'SUPPRESS'", "'SYMBOL'", "'SYMBOLIC'", "'SYNC'", "'SYNCHRONIZED'", 
			"'TALLYING'", "'TAPE'", "'TEST'", "'THAN'", "'THEN'", "'THROUGH'", "'THRU'", 
			"'TIME'", "'TIMES'", "'TO'", "'TOP'", "'TRAILING'", "'TRUE'", "'TYPE'", 
			"'UNIT'", "'UNBOUNDED'", "'UNTIL'", "'UNSTRING'", "'UP'", "'UPON'", "'USAGE'", 
			"'USE'", "'USING'", "'UTF-8'", "'VALIDATING'", "'VALUE'", "'VALUES'", 
			"'VARYING'", "'VOLATILE'", "'WHEN'", "'WITH'", "'WRITE'", "'WRITE-ONLY'", 
			"'WORDS'", "'WORKING-STORAGE'", "'XML'", "'XML-DECLARATION'", "'XML-SCHEMA'", 
			"'YYYYDDD'", "'YYYYMMDD'", "'ZERO'", "'ZEROES'", "'ZEROS'", "'+'", "'-'", 
			"'*'", "'/'", "':='", "','", "';'", "':'", "'='", "'<>'", "'<'", "'<='", 
			"'>='", "'>'", "'('", "')'", "'['", "'(.'", "']'", "'.)'", "'^'", "'@'", 
			"'.'", "'..'", "'{'", "'}'", "'&'", "'@@'", "'$'", null, null, null, 
			null, null, null, null, null, null, null, "'\\uFEFF'"
		};
	}
	private static final String[] _LITERAL_NAMES = makeLiteralNames();
	private static String[] makeSymbolicNames() {
		return new String[] {
			null, "KW_ACCEPT", "KW_ACCESS", "KW_ADD", "KW_ADDRESS", "KW_ADVANCING", 
			"KW_AFTER", "KW_ASCENDING", "KW_ALL", "KW_ALLOCATE", "KW_ALPHABET", "KW_ALPHABETIC", 
			"KW_ALPHABETIC_LOWER", "KW_ALPHABETIC_UPPER", "KW_ALSO", "KW_ALTER", 
			"KW_ALTERNATE", "KW_AND", "KW_ANY", "KW_APPLY", "KW_ARE", "KW_AREA", 
			"KW_AREAS", "KW_ASSIGN", "KW_AS", "KW_AT", "KW_ATTRIBUTE", "KW_ATTRIBUTES", 
			"KW_BEFORE", "KW_BINARY", "KW_BLANK", "KW_BLOCK", "KW_BOOL", "KW_BOOLEAN", 
			"KW_BOTTOM", "KW_BY", "KW_BYTE_LENGTH", "KW_CALL", "KW_CANCEL", "KW_CHARACTER", 
			"KW_CHARACTERS", "KW_CICS", "KW_CLASS", "KW_CLASS_ID", "KW_CLOSE", "KW_COBOL", 
			"KW_CODE_SET", "KW_COLLATING", "KW_COMMA", "KW_COMMON", "KW_COMP", "KW_COMP_1", 
			"KW_COMP_2", "KW_COMP_3", "KW_COMP_4", "KW_COMP_5", "KW_COMPUTATIONAL", 
			"KW_COMPUTATIONAL_1", "KW_COMPUTATIONAL_2", "KW_COMPUTATIONAL_3", "KW_COMPUTATIONAL_4", 
			"KW_COMPUTATIONAL_5", "KW_COMPUTE", "KW_CONFIGURATION", "KW_CONTAINS", 
			"KW_CONTENT", "KW_CONTINUE", "KW_CONVERTING", "KW_CORR", "KW_CORRESPONDING", 
			"KW_COUNT", "KW_CURRENCY", "KW_CYCLE", "KW_DATA", "KW_DATE", "KW_DAY", 
			"KW_DAY_OF_WEEK", "KW_DBCS", "KW_DEBUGGING", "KW_DECIMAL_POINT", "KW_DECLARATIVE", 
			"KW_DECLARATIVES", "KW_DEFAULT", "KW_DELETE", "KW_DELIMITED", "KW_DELIMITER", 
			"KW_DEPENDING", "KW_DESCENDING", "KW_DETAIL", "KW_DISPLAY", "KW_DISPLAY_1", 
			"KW_DIVIDE", "KW_DIVISION", "KW_DOWN", "KW_DUPLICATES", "KW_DYNAMIC", 
			"KW_EBCDIC", "KW_ELEMENT", "KW_ELSE", "KW_END", "KW_END_ADD", "KW_END_CALL", 
			"KW_END_COMPUTE", "KW_END_DELETE", "KW_END_DIVIDE", "KW_END_EVALUATE", 
			"KW_END_EXEC", "KW_END_IF", "KW_END_INVOKE", "KW_END_JSON", "KW_END_MULTIPLY", 
			"KW_END_OF_PAGE", "KW_END_PERFORM", "KW_END_READ", "KW_END_RETURN", "KW_END_REWRITE", 
			"KW_END_SEARCH", "KW_END_START", "KW_END_STRING", "KW_END_SUBTRACT", 
			"KW_END_UNSTRING", "KW_END_WRITE", "KW_END_XML", "KW_ENTRY", "KW_ENVIRONMENT", 
			"KW_EQUAL", "KW_EOP", "KW_ERROR", "KW_EVALUATE", "KW_EVERY", "KW_EXCEPTION", 
			"KW_EXEC", "KW_EXIT", "KW_EXTEND", "KW_EXTERNAL", "KW_FACTORY", "KW_FALSE", 
			"KW_FD", "KW_FILE", "KW_FILE_CONTROL", "KW_FILLER", "KW_FIRST", "KW_FIXED", 
			"KW_FOR", "KW_FOOTING", "KW_FREE", "KW_FROM", "KW_FUNCTION", "KW_FUNCTION_POINTER", 
			"KW_GENERATE", "KW_GLOBAL", "KW_GIVING", "KW_GO", "KW_GOBACK", "KW_GREATER", 
			"KW_GROUP_USAGE", "KW_HIGH_VALUE", "KW_HIGH_VALUES", "KW_ID", "KW_IDENTIFICATION", 
			"KW_IF", "KW_IN", "KW_INDEX", "KW_INDEXED", "KW_INHERITS", "KW_INITIAL", 
			"KW_INITIALIZE", "KW_INITIALIZED", "KW_INPUT", "KW_INPUT_OUTPUT", "KW_INSPECT", 
			"KW_INTO", "KW_INTRINSIC", "KW_INVALID", "KW_INVOKE", "KW_I_O", "KW_I_O_CONTROL", 
			"KW_IS", "KW_JSON", "KW_JUST", "KW_JUSTIFIED", "KW_KANJI", "KW_KEY", 
			"KW_LABEL", "KW_LEADING", "KW_LEFT", "KW_LENGTH", "KW_LESS", "KW_LIMIT", 
			"KW_LINAGE", "KW_LINE", "KW_LINES", "KW_LINKAGE", "KW_LOC", "KW_LOCK", 
			"KW_LOCAL_STORAGE", "KW_LOW_VALUE", "KW_LOW_VALUES", "KW_MEMORY", "KW_MERGE", 
			"KW_METHOD", "KW_METHOD_ID", "KW_MODE", "KW_MODULES", "KW_MOVE", "KW_MULTIPLE", 
			"KW_MULTIPLY", "KW_NAME", "KW_NAMESPACE", "KW_NAMESPACE_PREFIX", "KW_NATIVE", 
			"KW_NATIONAL", "KW_NEGATIVE", "KW_NEW", "KW_NEXT", "KW_NO", "KW_NOT", 
			"KW_NUMERIC", "KW_NONNUMERIC", "KW_NULL", "KW_NULLS", "KW_OBJECT", "KW_OBJECT_COMPUTER", 
			"KW_OCCURS", "KW_OUTPUT", "KW_OF", "KW_OFF", "KW_ON", "KW_OMITTED", "KW_OPEN", 
			"KW_OR", "KW_ORDER", "KW_ORGANIZATION", "KW_OPTIONAL", "KW_OTHER", "KW_OVERFLOW", 
			"KW_PACKED_DECIMAL", "KW_PADDING", "KW_PAGE", "KW_PARAGRAPH", "KW_PARSE", 
			"KW_PASSWORD", "KW_PERFORM", "KW_PIC", "KW_PICTURE", "KW_POINTER", "KW_POINTER_32", 
			"KW_POSITION", "KW_POSITIVE", "KW_PROCEDURE", "KW_PROCEDURE_POINTER", 
			"KW_PROCEDURES", "KW_PROCEED", "KW_PROCESSING", "KW_PROGRAM", "KW_PROGRAM_ID", 
			"KW_QUOTE", "KW_QUOTES", "KW_RANDOM", "KW_READ", "KW_RECORD", "KW_RECORDING", 
			"KW_RECORDS", "KW_RECURSIVE", "KW_REDEFINES", "KW_REEL", "KW_REFERENCE", 
			"KW_RELATIVE", "KW_RELEASE", "KW_REMAINDER", "KW_REMOVAL", "KW_RENAMES", 
			"KW_RERUN", "KW_RETURN", "KW_REPLACING", "KW_REPOSITORY", "KW_RESERVE", 
			"KW_RETURNING", "KW_REVERSED", "KW_REWIND", "KW_REWRITE", "KW_RIGHT", 
			"KW_ROUNDED", "KW_RUN", "KW_SD", "KW_SAME", "KW_SEARCH", "KW_SECTION", 
			"KW_SEGMENT_LIMIT", "KW_SELECT", "KW_SELF", "KW_SENTENCE", "KW_SEPARATE", 
			"KW_SEQUENCE", "KW_SEQUENTIAL", "KW_SET", "KW_SIGN", "KW_SIZE", "KW_SORT", 
			"KW_SORT_MERGE", "KW_SOURCE_COMPUTER", "KW_SPACE", "KW_SPACES", "KW_SPECIAL_NAMES", 
			"KW_SQL", "KW_SQLIMS", "KW_STANDARD", "KW_STANDARD_1", "KW_STANDARD_2", 
			"KW_START", "KW_STATUS", "KW_STOP", "KW_STRING", "KW_SUBTRACT", "KW_SUPER", 
			"KW_SUPPRESS", "KW_SYMBOL", "KW_SYMBOLIC", "KW_SYNC", "KW_SYNCHRONIZED", 
			"KW_TALLYING", "KW_TAPE", "KW_TEST", "KW_THAN", "KW_THEN", "KW_THROUGH", 
			"KW_THRU", "KW_TIME", "KW_TIMES", "KW_TO", "KW_TOP", "KW_TRAILING", "KW_TRUE", 
			"KW_TYPE", "KW_UNIT", "KW_UNBOUNDED", "KW_UNTIL", "KW_UNSTRING", "KW_UP", 
			"KW_UPON", "KW_USAGE", "KW_USE", "KW_USING", "KW_UTF_8", "KW_VALIDATING", 
			"KW_VALUE", "KW_VALUES", "KW_VARYING", "KW_VOLATILE", "KW_WHEN", "KW_WITH", 
			"KW_WRITE", "KW_WRITE_ONLY", "KW_WORDS", "KW_WORKING_STORAGE", "KW_XML", 
			"KW_XML_DECLARATION", "KW_XML_SCHEMA", "KW_YYYYDDD", "KW_YYYYMMDD", "KW_ZERO", 
			"KW_ZEROES", "KW_ZEROS", "PLUS", "MINUS", "STAR", "SLASH", "ASSIGN", 
			"COMMA", "SEMI", "COLON", "EQUAL", "NOT_EQUAL", "LT", "LE", "GE", "GT", 
			"LPAREN", "RPAREN", "LBRACK", "LBRACK2", "RBRACK", "RBRACK2", "POINTER2", 
			"AT2", "DOT", "DOTDOT", "LCURLY", "RCURLY", "AMBER", "DOUBLEAT", "DOLLAR", 
			"StringLiteral", "DbcsLiteral", "Utf8Literal", "HexNumber", "NullTerminated", 
			"IntegerLiteral", "DecimalLiteral", "Identifier", "EOL", "WS", "UnicodeBOM", 
			"PicString", "PicWS", "ANY"
		};
	}
	private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);

	/**
	 * @deprecated Use {@link #VOCABULARY} instead.
	 */
	@Deprecated
	public static final String[] tokenNames;
	static {
		tokenNames = new String[_SYMBOLIC_NAMES.length];
		for (int i = 0; i < tokenNames.length; i++) {
			tokenNames[i] = VOCABULARY.getLiteralName(i);
			if (tokenNames[i] == null) {
				tokenNames[i] = VOCABULARY.getSymbolicName(i);
			}

			if (tokenNames[i] == null) {
				tokenNames[i] = "<INVALID>";
			}
		}
	}

	@Override
	@Deprecated
	public String[] getTokenNames() {
		return tokenNames;
	}

	@Override

	public Vocabulary getVocabulary() {
		return VOCABULARY;
	}

	@Override
	public String getGrammarFileName() { return "SyntaxParser.g4"; }

	@Override
	public String[] getRuleNames() { return ruleNames; }

	@Override
	public String getSerializedATN() { return _serializedATN; }

	@Override
	public ATN getATN() { return _ATN; }

	public SyntaxParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}

	@SuppressWarnings("CheckReturnValue")
	public static class FileContext extends ParserRuleContext {
		public TerminalNode EOF() { return getToken(SyntaxParser.EOF, 0); }
		public List<DataDescriptionContext> dataDescription() {
			return getRuleContexts(DataDescriptionContext.class);
		}
		public DataDescriptionContext dataDescription(int i) {
			return getRuleContext(DataDescriptionContext.class,i);
		}
		public List<LineContext> line() {
			return getRuleContexts(LineContext.class);
		}
		public LineContext line(int i) {
			return getRuleContext(LineContext.class,i);
		}
		public FileContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_file; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SyntaxParserListener ) ((SyntaxParserListener)listener).enterFile(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SyntaxParserListener ) ((SyntaxParserListener)listener).exitFile(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof SyntaxParserVisitor ) return ((SyntaxParserVisitor<? extends T>)visitor).visitFile(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FileContext file() throws RecognitionException {
		FileContext _localctx = new FileContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_file);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(28);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -1L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & -1L) != 0) || ((((_la - 192)) & ~0x3f) == 0 && ((1L << (_la - 192)) & -1L) != 0) || ((((_la - 256)) & ~0x3f) == 0 && ((1L << (_la - 256)) & -1L) != 0) || ((((_la - 320)) & ~0x3f) == 0 && ((1L << (_la - 320)) & -1L) != 0) || ((((_la - 384)) & ~0x3f) == 0 && ((1L << (_la - 384)) & 4194303L) != 0)) {
				{
				setState(26);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
				case 1:
					{
					setState(24);
					dataDescription();
					}
					break;
				case 2:
					{
					setState(25);
					line();
					}
					break;
				}
				}
				setState(30);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(31);
			match(EOF);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class DataDescriptionContext extends ParserRuleContext {
		public LevelNumContext levelNum() {
			return getRuleContext(LevelNumContext.class,0);
		}
		public TerminalNode EOL() { return getToken(SyntaxParser.EOL, 0); }
		public データ名Context データ名() {
			return getRuleContext(データ名Context.class,0);
		}
		public TerminalNode KW_FILLER() { return getToken(SyntaxParser.KW_FILLER, 0); }
		public List<WordContext> word() {
			return getRuleContexts(WordContext.class);
		}
		public WordContext word(int i) {
			return getRuleContext(WordContext.class,i);
		}
		public List<TerminalNode> PicString() { return getTokens(SyntaxParser.PicString); }
		public TerminalNode PicString(int i) {
			return getToken(SyntaxParser.PicString, i);
		}
		public List<TerminalNode> KW_PIC() { return getTokens(SyntaxParser.KW_PIC); }
		public TerminalNode KW_PIC(int i) {
			return getToken(SyntaxParser.KW_PIC, i);
		}
		public List<TerminalNode> KW_PICTURE() { return getTokens(SyntaxParser.KW_PICTURE); }
		public TerminalNode KW_PICTURE(int i) {
			return getToken(SyntaxParser.KW_PICTURE, i);
		}
		public List<TerminalNode> KW_IS() { return getTokens(SyntaxParser.KW_IS); }
		public TerminalNode KW_IS(int i) {
			return getToken(SyntaxParser.KW_IS, i);
		}
		public DataDescriptionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_dataDescription; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SyntaxParserListener ) ((SyntaxParserListener)listener).enterDataDescription(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SyntaxParserListener ) ((SyntaxParserListener)listener).exitDataDescription(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof SyntaxParserVisitor ) return ((SyntaxParserVisitor<? extends T>)visitor).visitDataDescription(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DataDescriptionContext dataDescription() throws RecognitionException {
		DataDescriptionContext _localctx = new DataDescriptionContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_dataDescription);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(33);
			levelNum();
			setState(36);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case Identifier:
				{
				setState(34);
				データ名();
				}
				break;
			case KW_FILLER:
				{
				setState(35);
				match(KW_FILLER);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(46);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -1L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & -1L) != 0) || ((((_la - 192)) & ~0x3f) == 0 && ((1L << (_la - 192)) & -1L) != 0) || ((((_la - 256)) & ~0x3f) == 0 && ((1L << (_la - 256)) & -1L) != 0) || ((((_la - 320)) & ~0x3f) == 0 && ((1L << (_la - 320)) & -1L) != 0) || ((((_la - 384)) & ~0x3f) == 0 && ((1L << (_la - 384)) & 4128767L) != 0)) {
				{
				setState(44);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
				case 1:
					{
					{
					setState(38);
					_la = _input.LA(1);
					if ( !(_la==KW_PIC || _la==KW_PICTURE) ) {
					_errHandler.recoverInline(this);
					}
					else {
						if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
						_errHandler.reportMatch(this);
						consume();
					}
					setState(40);
					_errHandler.sync(this);
					_la = _input.LA(1);
					if (_la==KW_IS) {
						{
						setState(39);
						match(KW_IS);
						}
					}

					setState(42);
					match(PicString);
					}
					}
					break;
				case 2:
					{
					setState(43);
					word();
					}
					break;
				}
				}
				setState(48);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(49);
			match(EOL);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class LevelNumContext extends ParserRuleContext {
		public TerminalNode IntegerLiteral() { return getToken(SyntaxParser.IntegerLiteral, 0); }
		public LevelNumContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_levelNum; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SyntaxParserListener ) ((SyntaxParserListener)listener).enterLevelNum(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SyntaxParserListener ) ((SyntaxParserListener)listener).exitLevelNum(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof SyntaxParserVisitor ) return ((SyntaxParserVisitor<? extends T>)visitor).visitLevelNum(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LevelNumContext levelNum() throws RecognitionException {
		LevelNumContext _localctx = new LevelNumContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_levelNum);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(51);
			match(IntegerLiteral);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class データ名Context extends ParserRuleContext {
		public TerminalNode Identifier() { return getToken(SyntaxParser.Identifier, 0); }
		public データ名Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_データ名; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SyntaxParserListener ) ((SyntaxParserListener)listener).enterデータ名(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SyntaxParserListener ) ((SyntaxParserListener)listener).exitデータ名(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof SyntaxParserVisitor ) return ((SyntaxParserVisitor<? extends T>)visitor).visitデータ名(this);
			else return visitor.visitChildren(this);
		}
	}

	public final データ名Context データ名() throws RecognitionException {
		データ名Context _localctx = new データ名Context(_ctx, getState());
		enterRule(_localctx, 6, RULE_データ名);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(53);
			match(Identifier);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ExecStmtContext extends ParserRuleContext {
		public TerminalNode KW_EXEC() { return getToken(SyntaxParser.KW_EXEC, 0); }
		public WordListContext wordList() {
			return getRuleContext(WordListContext.class,0);
		}
		public TerminalNode KW_END_EXEC() { return getToken(SyntaxParser.KW_END_EXEC, 0); }
		public TerminalNode EOL() { return getToken(SyntaxParser.EOL, 0); }
		public ExecStmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_execStmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SyntaxParserListener ) ((SyntaxParserListener)listener).enterExecStmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SyntaxParserListener ) ((SyntaxParserListener)listener).exitExecStmt(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof SyntaxParserVisitor ) return ((SyntaxParserVisitor<? extends T>)visitor).visitExecStmt(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExecStmtContext execStmt() throws RecognitionException {
		ExecStmtContext _localctx = new ExecStmtContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_execStmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(55);
			match(KW_EXEC);
			setState(56);
			wordList();
			setState(57);
			match(KW_END_EXEC);
			setState(58);
			match(EOL);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class LineContext extends ParserRuleContext {
		public WordListContext wordList() {
			return getRuleContext(WordListContext.class,0);
		}
		public TerminalNode EOL() { return getToken(SyntaxParser.EOL, 0); }
		public LineContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_line; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SyntaxParserListener ) ((SyntaxParserListener)listener).enterLine(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SyntaxParserListener ) ((SyntaxParserListener)listener).exitLine(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof SyntaxParserVisitor ) return ((SyntaxParserVisitor<? extends T>)visitor).visitLine(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LineContext line() throws RecognitionException {
		LineContext _localctx = new LineContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_line);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(60);
			wordList();
			setState(61);
			match(EOL);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class WordListContext extends ParserRuleContext {
		public List<WordContext> word() {
			return getRuleContexts(WordContext.class);
		}
		public WordContext word(int i) {
			return getRuleContext(WordContext.class,i);
		}
		public WordListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_wordList; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SyntaxParserListener ) ((SyntaxParserListener)listener).enterWordList(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SyntaxParserListener ) ((SyntaxParserListener)listener).exitWordList(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof SyntaxParserVisitor ) return ((SyntaxParserVisitor<? extends T>)visitor).visitWordList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final WordListContext wordList() throws RecognitionException {
		WordListContext _localctx = new WordListContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_wordList);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(66);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,6,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(63);
					word();
					}
					} 
				}
				setState(68);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,6,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class WordContext extends ParserRuleContext {
		public TerminalNode EOL() { return getToken(SyntaxParser.EOL, 0); }
		public WordContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_word; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SyntaxParserListener ) ((SyntaxParserListener)listener).enterWord(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SyntaxParserListener ) ((SyntaxParserListener)listener).exitWord(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof SyntaxParserVisitor ) return ((SyntaxParserVisitor<? extends T>)visitor).visitWord(this);
			else return visitor.visitChildren(this);
		}
	}

	public final WordContext word() throws RecognitionException {
		WordContext _localctx = new WordContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_word);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(69);
			_la = _input.LA(1);
			if ( _la <= 0 || (_la==EOL) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class LiteralContext extends ParserRuleContext {
		public NumericLiteralContext numericLiteral() {
			return getRuleContext(NumericLiteralContext.class,0);
		}
		public NonnumericLiteralContext nonnumericLiteral() {
			return getRuleContext(NonnumericLiteralContext.class,0);
		}
		public LiteralContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_literal; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SyntaxParserListener ) ((SyntaxParserListener)listener).enterLiteral(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SyntaxParserListener ) ((SyntaxParserListener)listener).exitLiteral(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof SyntaxParserVisitor ) return ((SyntaxParserVisitor<? extends T>)visitor).visitLiteral(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LiteralContext literal() throws RecognitionException {
		LiteralContext _localctx = new LiteralContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_literal);
		try {
			setState(73);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case IntegerLiteral:
			case DecimalLiteral:
				enterOuterAlt(_localctx, 1);
				{
				setState(71);
				numericLiteral();
				}
				break;
			case StringLiteral:
			case DbcsLiteral:
			case Utf8Literal:
			case HexNumber:
			case NullTerminated:
				enterOuterAlt(_localctx, 2);
				{
				setState(72);
				nonnumericLiteral();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class NumericLiteralContext extends ParserRuleContext {
		public TerminalNode DecimalLiteral() { return getToken(SyntaxParser.DecimalLiteral, 0); }
		public TerminalNode IntegerLiteral() { return getToken(SyntaxParser.IntegerLiteral, 0); }
		public NumericLiteralContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_numericLiteral; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SyntaxParserListener ) ((SyntaxParserListener)listener).enterNumericLiteral(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SyntaxParserListener ) ((SyntaxParserListener)listener).exitNumericLiteral(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof SyntaxParserVisitor ) return ((SyntaxParserVisitor<? extends T>)visitor).visitNumericLiteral(this);
			else return visitor.visitChildren(this);
		}
	}

	public final NumericLiteralContext numericLiteral() throws RecognitionException {
		NumericLiteralContext _localctx = new NumericLiteralContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_numericLiteral);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(75);
			_la = _input.LA(1);
			if ( !(_la==IntegerLiteral || _la==DecimalLiteral) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class NonnumericLiteralContext extends ParserRuleContext {
		public TerminalNode StringLiteral() { return getToken(SyntaxParser.StringLiteral, 0); }
		public TerminalNode DbcsLiteral() { return getToken(SyntaxParser.DbcsLiteral, 0); }
		public TerminalNode Utf8Literal() { return getToken(SyntaxParser.Utf8Literal, 0); }
		public TerminalNode HexNumber() { return getToken(SyntaxParser.HexNumber, 0); }
		public TerminalNode NullTerminated() { return getToken(SyntaxParser.NullTerminated, 0); }
		public NonnumericLiteralContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_nonnumericLiteral; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SyntaxParserListener ) ((SyntaxParserListener)listener).enterNonnumericLiteral(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SyntaxParserListener ) ((SyntaxParserListener)listener).exitNonnumericLiteral(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof SyntaxParserVisitor ) return ((SyntaxParserVisitor<? extends T>)visitor).visitNonnumericLiteral(this);
			else return visitor.visitChildren(this);
		}
	}

	public final NonnumericLiteralContext nonnumericLiteral() throws RecognitionException {
		NonnumericLiteralContext _localctx = new NonnumericLiteralContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_nonnumericLiteral);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(77);
			_la = _input.LA(1);
			if ( !(((((_la - 392)) & ~0x3f) == 0 && ((1L << (_la - 392)) & 31L) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class KeywordContext extends ParserRuleContext {
		public TerminalNode KW_ACCEPT() { return getToken(SyntaxParser.KW_ACCEPT, 0); }
		public TerminalNode KW_ACCESS() { return getToken(SyntaxParser.KW_ACCESS, 0); }
		public TerminalNode KW_ADD() { return getToken(SyntaxParser.KW_ADD, 0); }
		public TerminalNode KW_ADDRESS() { return getToken(SyntaxParser.KW_ADDRESS, 0); }
		public TerminalNode KW_ADVANCING() { return getToken(SyntaxParser.KW_ADVANCING, 0); }
		public TerminalNode KW_AFTER() { return getToken(SyntaxParser.KW_AFTER, 0); }
		public TerminalNode KW_ASCENDING() { return getToken(SyntaxParser.KW_ASCENDING, 0); }
		public TerminalNode KW_ALL() { return getToken(SyntaxParser.KW_ALL, 0); }
		public TerminalNode KW_ALLOCATE() { return getToken(SyntaxParser.KW_ALLOCATE, 0); }
		public TerminalNode KW_ALPHABET() { return getToken(SyntaxParser.KW_ALPHABET, 0); }
		public TerminalNode KW_ALPHABETIC() { return getToken(SyntaxParser.KW_ALPHABETIC, 0); }
		public TerminalNode KW_ALPHABETIC_LOWER() { return getToken(SyntaxParser.KW_ALPHABETIC_LOWER, 0); }
		public TerminalNode KW_ALPHABETIC_UPPER() { return getToken(SyntaxParser.KW_ALPHABETIC_UPPER, 0); }
		public TerminalNode KW_ALSO() { return getToken(SyntaxParser.KW_ALSO, 0); }
		public TerminalNode KW_ALTER() { return getToken(SyntaxParser.KW_ALTER, 0); }
		public TerminalNode KW_ALTERNATE() { return getToken(SyntaxParser.KW_ALTERNATE, 0); }
		public TerminalNode KW_AND() { return getToken(SyntaxParser.KW_AND, 0); }
		public TerminalNode KW_ANY() { return getToken(SyntaxParser.KW_ANY, 0); }
		public TerminalNode KW_APPLY() { return getToken(SyntaxParser.KW_APPLY, 0); }
		public TerminalNode KW_ARE() { return getToken(SyntaxParser.KW_ARE, 0); }
		public TerminalNode KW_AREA() { return getToken(SyntaxParser.KW_AREA, 0); }
		public TerminalNode KW_AREAS() { return getToken(SyntaxParser.KW_AREAS, 0); }
		public TerminalNode KW_ASSIGN() { return getToken(SyntaxParser.KW_ASSIGN, 0); }
		public TerminalNode KW_AS() { return getToken(SyntaxParser.KW_AS, 0); }
		public TerminalNode KW_AT() { return getToken(SyntaxParser.KW_AT, 0); }
		public TerminalNode KW_ATTRIBUTE() { return getToken(SyntaxParser.KW_ATTRIBUTE, 0); }
		public TerminalNode KW_ATTRIBUTES() { return getToken(SyntaxParser.KW_ATTRIBUTES, 0); }
		public TerminalNode KW_BEFORE() { return getToken(SyntaxParser.KW_BEFORE, 0); }
		public TerminalNode KW_BINARY() { return getToken(SyntaxParser.KW_BINARY, 0); }
		public TerminalNode KW_BLANK() { return getToken(SyntaxParser.KW_BLANK, 0); }
		public TerminalNode KW_BLOCK() { return getToken(SyntaxParser.KW_BLOCK, 0); }
		public TerminalNode KW_BOOL() { return getToken(SyntaxParser.KW_BOOL, 0); }
		public TerminalNode KW_BOOLEAN() { return getToken(SyntaxParser.KW_BOOLEAN, 0); }
		public TerminalNode KW_BOTTOM() { return getToken(SyntaxParser.KW_BOTTOM, 0); }
		public TerminalNode KW_BY() { return getToken(SyntaxParser.KW_BY, 0); }
		public TerminalNode KW_BYTE_LENGTH() { return getToken(SyntaxParser.KW_BYTE_LENGTH, 0); }
		public TerminalNode KW_CALL() { return getToken(SyntaxParser.KW_CALL, 0); }
		public TerminalNode KW_CANCEL() { return getToken(SyntaxParser.KW_CANCEL, 0); }
		public TerminalNode KW_CHARACTER() { return getToken(SyntaxParser.KW_CHARACTER, 0); }
		public TerminalNode KW_CHARACTERS() { return getToken(SyntaxParser.KW_CHARACTERS, 0); }
		public TerminalNode KW_CICS() { return getToken(SyntaxParser.KW_CICS, 0); }
		public TerminalNode KW_CLASS() { return getToken(SyntaxParser.KW_CLASS, 0); }
		public TerminalNode KW_CLASS_ID() { return getToken(SyntaxParser.KW_CLASS_ID, 0); }
		public TerminalNode KW_CLOSE() { return getToken(SyntaxParser.KW_CLOSE, 0); }
		public TerminalNode KW_COBOL() { return getToken(SyntaxParser.KW_COBOL, 0); }
		public TerminalNode KW_CODE_SET() { return getToken(SyntaxParser.KW_CODE_SET, 0); }
		public TerminalNode KW_COLLATING() { return getToken(SyntaxParser.KW_COLLATING, 0); }
		public TerminalNode KW_COMMA() { return getToken(SyntaxParser.KW_COMMA, 0); }
		public TerminalNode KW_COMMON() { return getToken(SyntaxParser.KW_COMMON, 0); }
		public TerminalNode KW_COMP() { return getToken(SyntaxParser.KW_COMP, 0); }
		public TerminalNode KW_COMP_1() { return getToken(SyntaxParser.KW_COMP_1, 0); }
		public TerminalNode KW_COMP_2() { return getToken(SyntaxParser.KW_COMP_2, 0); }
		public TerminalNode KW_COMP_3() { return getToken(SyntaxParser.KW_COMP_3, 0); }
		public TerminalNode KW_COMP_4() { return getToken(SyntaxParser.KW_COMP_4, 0); }
		public TerminalNode KW_COMP_5() { return getToken(SyntaxParser.KW_COMP_5, 0); }
		public TerminalNode KW_COMPUTATIONAL() { return getToken(SyntaxParser.KW_COMPUTATIONAL, 0); }
		public TerminalNode KW_COMPUTATIONAL_1() { return getToken(SyntaxParser.KW_COMPUTATIONAL_1, 0); }
		public TerminalNode KW_COMPUTATIONAL_2() { return getToken(SyntaxParser.KW_COMPUTATIONAL_2, 0); }
		public TerminalNode KW_COMPUTATIONAL_3() { return getToken(SyntaxParser.KW_COMPUTATIONAL_3, 0); }
		public TerminalNode KW_COMPUTATIONAL_4() { return getToken(SyntaxParser.KW_COMPUTATIONAL_4, 0); }
		public TerminalNode KW_COMPUTATIONAL_5() { return getToken(SyntaxParser.KW_COMPUTATIONAL_5, 0); }
		public TerminalNode KW_COMPUTE() { return getToken(SyntaxParser.KW_COMPUTE, 0); }
		public TerminalNode KW_CONFIGURATION() { return getToken(SyntaxParser.KW_CONFIGURATION, 0); }
		public TerminalNode KW_CONTAINS() { return getToken(SyntaxParser.KW_CONTAINS, 0); }
		public TerminalNode KW_CONTENT() { return getToken(SyntaxParser.KW_CONTENT, 0); }
		public TerminalNode KW_CONTINUE() { return getToken(SyntaxParser.KW_CONTINUE, 0); }
		public TerminalNode KW_CONVERTING() { return getToken(SyntaxParser.KW_CONVERTING, 0); }
		public TerminalNode KW_CORR() { return getToken(SyntaxParser.KW_CORR, 0); }
		public TerminalNode KW_CORRESPONDING() { return getToken(SyntaxParser.KW_CORRESPONDING, 0); }
		public TerminalNode KW_COUNT() { return getToken(SyntaxParser.KW_COUNT, 0); }
		public TerminalNode KW_CURRENCY() { return getToken(SyntaxParser.KW_CURRENCY, 0); }
		public TerminalNode KW_CYCLE() { return getToken(SyntaxParser.KW_CYCLE, 0); }
		public TerminalNode KW_DATA() { return getToken(SyntaxParser.KW_DATA, 0); }
		public TerminalNode KW_DATE() { return getToken(SyntaxParser.KW_DATE, 0); }
		public TerminalNode KW_DAY() { return getToken(SyntaxParser.KW_DAY, 0); }
		public TerminalNode KW_DAY_OF_WEEK() { return getToken(SyntaxParser.KW_DAY_OF_WEEK, 0); }
		public TerminalNode KW_DBCS() { return getToken(SyntaxParser.KW_DBCS, 0); }
		public TerminalNode KW_DEBUGGING() { return getToken(SyntaxParser.KW_DEBUGGING, 0); }
		public TerminalNode KW_DECIMAL_POINT() { return getToken(SyntaxParser.KW_DECIMAL_POINT, 0); }
		public TerminalNode KW_DECLARATIVE() { return getToken(SyntaxParser.KW_DECLARATIVE, 0); }
		public TerminalNode KW_DECLARATIVES() { return getToken(SyntaxParser.KW_DECLARATIVES, 0); }
		public TerminalNode KW_DEFAULT() { return getToken(SyntaxParser.KW_DEFAULT, 0); }
		public TerminalNode KW_DELETE() { return getToken(SyntaxParser.KW_DELETE, 0); }
		public TerminalNode KW_DELIMITED() { return getToken(SyntaxParser.KW_DELIMITED, 0); }
		public TerminalNode KW_DELIMITER() { return getToken(SyntaxParser.KW_DELIMITER, 0); }
		public TerminalNode KW_DEPENDING() { return getToken(SyntaxParser.KW_DEPENDING, 0); }
		public TerminalNode KW_DESCENDING() { return getToken(SyntaxParser.KW_DESCENDING, 0); }
		public TerminalNode KW_DETAIL() { return getToken(SyntaxParser.KW_DETAIL, 0); }
		public TerminalNode KW_DISPLAY() { return getToken(SyntaxParser.KW_DISPLAY, 0); }
		public TerminalNode KW_DISPLAY_1() { return getToken(SyntaxParser.KW_DISPLAY_1, 0); }
		public TerminalNode KW_DIVIDE() { return getToken(SyntaxParser.KW_DIVIDE, 0); }
		public TerminalNode KW_DIVISION() { return getToken(SyntaxParser.KW_DIVISION, 0); }
		public TerminalNode KW_DOWN() { return getToken(SyntaxParser.KW_DOWN, 0); }
		public TerminalNode KW_DUPLICATES() { return getToken(SyntaxParser.KW_DUPLICATES, 0); }
		public TerminalNode KW_DYNAMIC() { return getToken(SyntaxParser.KW_DYNAMIC, 0); }
		public TerminalNode KW_EBCDIC() { return getToken(SyntaxParser.KW_EBCDIC, 0); }
		public TerminalNode KW_ELEMENT() { return getToken(SyntaxParser.KW_ELEMENT, 0); }
		public TerminalNode KW_ELSE() { return getToken(SyntaxParser.KW_ELSE, 0); }
		public TerminalNode KW_END() { return getToken(SyntaxParser.KW_END, 0); }
		public TerminalNode KW_END_ADD() { return getToken(SyntaxParser.KW_END_ADD, 0); }
		public TerminalNode KW_END_CALL() { return getToken(SyntaxParser.KW_END_CALL, 0); }
		public TerminalNode KW_END_COMPUTE() { return getToken(SyntaxParser.KW_END_COMPUTE, 0); }
		public TerminalNode KW_END_DELETE() { return getToken(SyntaxParser.KW_END_DELETE, 0); }
		public TerminalNode KW_END_DIVIDE() { return getToken(SyntaxParser.KW_END_DIVIDE, 0); }
		public TerminalNode KW_END_EVALUATE() { return getToken(SyntaxParser.KW_END_EVALUATE, 0); }
		public TerminalNode KW_END_EXEC() { return getToken(SyntaxParser.KW_END_EXEC, 0); }
		public TerminalNode KW_END_IF() { return getToken(SyntaxParser.KW_END_IF, 0); }
		public TerminalNode KW_END_INVOKE() { return getToken(SyntaxParser.KW_END_INVOKE, 0); }
		public TerminalNode KW_END_JSON() { return getToken(SyntaxParser.KW_END_JSON, 0); }
		public TerminalNode KW_END_MULTIPLY() { return getToken(SyntaxParser.KW_END_MULTIPLY, 0); }
		public TerminalNode KW_END_OF_PAGE() { return getToken(SyntaxParser.KW_END_OF_PAGE, 0); }
		public TerminalNode KW_END_PERFORM() { return getToken(SyntaxParser.KW_END_PERFORM, 0); }
		public TerminalNode KW_END_READ() { return getToken(SyntaxParser.KW_END_READ, 0); }
		public TerminalNode KW_END_RETURN() { return getToken(SyntaxParser.KW_END_RETURN, 0); }
		public TerminalNode KW_END_REWRITE() { return getToken(SyntaxParser.KW_END_REWRITE, 0); }
		public TerminalNode KW_END_SEARCH() { return getToken(SyntaxParser.KW_END_SEARCH, 0); }
		public TerminalNode KW_END_START() { return getToken(SyntaxParser.KW_END_START, 0); }
		public TerminalNode KW_END_STRING() { return getToken(SyntaxParser.KW_END_STRING, 0); }
		public TerminalNode KW_END_SUBTRACT() { return getToken(SyntaxParser.KW_END_SUBTRACT, 0); }
		public TerminalNode KW_END_UNSTRING() { return getToken(SyntaxParser.KW_END_UNSTRING, 0); }
		public TerminalNode KW_END_WRITE() { return getToken(SyntaxParser.KW_END_WRITE, 0); }
		public TerminalNode KW_END_XML() { return getToken(SyntaxParser.KW_END_XML, 0); }
		public TerminalNode KW_ENTRY() { return getToken(SyntaxParser.KW_ENTRY, 0); }
		public TerminalNode KW_ENVIRONMENT() { return getToken(SyntaxParser.KW_ENVIRONMENT, 0); }
		public TerminalNode KW_EQUAL() { return getToken(SyntaxParser.KW_EQUAL, 0); }
		public TerminalNode KW_EOP() { return getToken(SyntaxParser.KW_EOP, 0); }
		public TerminalNode KW_ERROR() { return getToken(SyntaxParser.KW_ERROR, 0); }
		public TerminalNode KW_EVALUATE() { return getToken(SyntaxParser.KW_EVALUATE, 0); }
		public TerminalNode KW_EVERY() { return getToken(SyntaxParser.KW_EVERY, 0); }
		public TerminalNode KW_EXCEPTION() { return getToken(SyntaxParser.KW_EXCEPTION, 0); }
		public TerminalNode KW_EXEC() { return getToken(SyntaxParser.KW_EXEC, 0); }
		public TerminalNode KW_EXIT() { return getToken(SyntaxParser.KW_EXIT, 0); }
		public TerminalNode KW_EXTEND() { return getToken(SyntaxParser.KW_EXTEND, 0); }
		public TerminalNode KW_EXTERNAL() { return getToken(SyntaxParser.KW_EXTERNAL, 0); }
		public TerminalNode KW_FACTORY() { return getToken(SyntaxParser.KW_FACTORY, 0); }
		public TerminalNode KW_FALSE() { return getToken(SyntaxParser.KW_FALSE, 0); }
		public TerminalNode KW_FD() { return getToken(SyntaxParser.KW_FD, 0); }
		public TerminalNode KW_FILE() { return getToken(SyntaxParser.KW_FILE, 0); }
		public TerminalNode KW_FILE_CONTROL() { return getToken(SyntaxParser.KW_FILE_CONTROL, 0); }
		public TerminalNode KW_FILLER() { return getToken(SyntaxParser.KW_FILLER, 0); }
		public TerminalNode KW_FIRST() { return getToken(SyntaxParser.KW_FIRST, 0); }
		public TerminalNode KW_FIXED() { return getToken(SyntaxParser.KW_FIXED, 0); }
		public TerminalNode KW_FOR() { return getToken(SyntaxParser.KW_FOR, 0); }
		public TerminalNode KW_FOOTING() { return getToken(SyntaxParser.KW_FOOTING, 0); }
		public TerminalNode KW_FREE() { return getToken(SyntaxParser.KW_FREE, 0); }
		public TerminalNode KW_FROM() { return getToken(SyntaxParser.KW_FROM, 0); }
		public TerminalNode KW_FUNCTION() { return getToken(SyntaxParser.KW_FUNCTION, 0); }
		public TerminalNode KW_FUNCTION_POINTER() { return getToken(SyntaxParser.KW_FUNCTION_POINTER, 0); }
		public TerminalNode KW_GENERATE() { return getToken(SyntaxParser.KW_GENERATE, 0); }
		public TerminalNode KW_GLOBAL() { return getToken(SyntaxParser.KW_GLOBAL, 0); }
		public TerminalNode KW_GIVING() { return getToken(SyntaxParser.KW_GIVING, 0); }
		public TerminalNode KW_GO() { return getToken(SyntaxParser.KW_GO, 0); }
		public TerminalNode KW_GOBACK() { return getToken(SyntaxParser.KW_GOBACK, 0); }
		public TerminalNode KW_GREATER() { return getToken(SyntaxParser.KW_GREATER, 0); }
		public TerminalNode KW_GROUP_USAGE() { return getToken(SyntaxParser.KW_GROUP_USAGE, 0); }
		public TerminalNode KW_HIGH_VALUE() { return getToken(SyntaxParser.KW_HIGH_VALUE, 0); }
		public TerminalNode KW_HIGH_VALUES() { return getToken(SyntaxParser.KW_HIGH_VALUES, 0); }
		public TerminalNode KW_ID() { return getToken(SyntaxParser.KW_ID, 0); }
		public TerminalNode KW_IDENTIFICATION() { return getToken(SyntaxParser.KW_IDENTIFICATION, 0); }
		public TerminalNode KW_IF() { return getToken(SyntaxParser.KW_IF, 0); }
		public TerminalNode KW_IN() { return getToken(SyntaxParser.KW_IN, 0); }
		public TerminalNode KW_INDEX() { return getToken(SyntaxParser.KW_INDEX, 0); }
		public TerminalNode KW_INDEXED() { return getToken(SyntaxParser.KW_INDEXED, 0); }
		public TerminalNode KW_INHERITS() { return getToken(SyntaxParser.KW_INHERITS, 0); }
		public TerminalNode KW_INITIAL() { return getToken(SyntaxParser.KW_INITIAL, 0); }
		public TerminalNode KW_INITIALIZE() { return getToken(SyntaxParser.KW_INITIALIZE, 0); }
		public TerminalNode KW_INITIALIZED() { return getToken(SyntaxParser.KW_INITIALIZED, 0); }
		public TerminalNode KW_INPUT() { return getToken(SyntaxParser.KW_INPUT, 0); }
		public TerminalNode KW_INPUT_OUTPUT() { return getToken(SyntaxParser.KW_INPUT_OUTPUT, 0); }
		public TerminalNode KW_INSPECT() { return getToken(SyntaxParser.KW_INSPECT, 0); }
		public TerminalNode KW_INTO() { return getToken(SyntaxParser.KW_INTO, 0); }
		public TerminalNode KW_INTRINSIC() { return getToken(SyntaxParser.KW_INTRINSIC, 0); }
		public TerminalNode KW_INVALID() { return getToken(SyntaxParser.KW_INVALID, 0); }
		public TerminalNode KW_INVOKE() { return getToken(SyntaxParser.KW_INVOKE, 0); }
		public TerminalNode KW_I_O() { return getToken(SyntaxParser.KW_I_O, 0); }
		public TerminalNode KW_I_O_CONTROL() { return getToken(SyntaxParser.KW_I_O_CONTROL, 0); }
		public TerminalNode KW_IS() { return getToken(SyntaxParser.KW_IS, 0); }
		public TerminalNode KW_JSON() { return getToken(SyntaxParser.KW_JSON, 0); }
		public TerminalNode KW_JUST() { return getToken(SyntaxParser.KW_JUST, 0); }
		public TerminalNode KW_JUSTIFIED() { return getToken(SyntaxParser.KW_JUSTIFIED, 0); }
		public TerminalNode KW_KANJI() { return getToken(SyntaxParser.KW_KANJI, 0); }
		public TerminalNode KW_KEY() { return getToken(SyntaxParser.KW_KEY, 0); }
		public TerminalNode KW_LABEL() { return getToken(SyntaxParser.KW_LABEL, 0); }
		public TerminalNode KW_LEADING() { return getToken(SyntaxParser.KW_LEADING, 0); }
		public TerminalNode KW_LEFT() { return getToken(SyntaxParser.KW_LEFT, 0); }
		public TerminalNode KW_LENGTH() { return getToken(SyntaxParser.KW_LENGTH, 0); }
		public TerminalNode KW_LESS() { return getToken(SyntaxParser.KW_LESS, 0); }
		public TerminalNode KW_LIMIT() { return getToken(SyntaxParser.KW_LIMIT, 0); }
		public TerminalNode KW_LINAGE() { return getToken(SyntaxParser.KW_LINAGE, 0); }
		public TerminalNode KW_LINE() { return getToken(SyntaxParser.KW_LINE, 0); }
		public TerminalNode KW_LINES() { return getToken(SyntaxParser.KW_LINES, 0); }
		public TerminalNode KW_LINKAGE() { return getToken(SyntaxParser.KW_LINKAGE, 0); }
		public TerminalNode KW_LOC() { return getToken(SyntaxParser.KW_LOC, 0); }
		public TerminalNode KW_LOCK() { return getToken(SyntaxParser.KW_LOCK, 0); }
		public TerminalNode KW_LOCAL_STORAGE() { return getToken(SyntaxParser.KW_LOCAL_STORAGE, 0); }
		public TerminalNode KW_LOW_VALUE() { return getToken(SyntaxParser.KW_LOW_VALUE, 0); }
		public TerminalNode KW_LOW_VALUES() { return getToken(SyntaxParser.KW_LOW_VALUES, 0); }
		public TerminalNode KW_MEMORY() { return getToken(SyntaxParser.KW_MEMORY, 0); }
		public TerminalNode KW_MERGE() { return getToken(SyntaxParser.KW_MERGE, 0); }
		public TerminalNode KW_METHOD() { return getToken(SyntaxParser.KW_METHOD, 0); }
		public TerminalNode KW_METHOD_ID() { return getToken(SyntaxParser.KW_METHOD_ID, 0); }
		public TerminalNode KW_MODE() { return getToken(SyntaxParser.KW_MODE, 0); }
		public TerminalNode KW_MODULES() { return getToken(SyntaxParser.KW_MODULES, 0); }
		public TerminalNode KW_MOVE() { return getToken(SyntaxParser.KW_MOVE, 0); }
		public TerminalNode KW_MULTIPLE() { return getToken(SyntaxParser.KW_MULTIPLE, 0); }
		public TerminalNode KW_MULTIPLY() { return getToken(SyntaxParser.KW_MULTIPLY, 0); }
		public TerminalNode KW_NAME() { return getToken(SyntaxParser.KW_NAME, 0); }
		public TerminalNode KW_NAMESPACE() { return getToken(SyntaxParser.KW_NAMESPACE, 0); }
		public TerminalNode KW_NAMESPACE_PREFIX() { return getToken(SyntaxParser.KW_NAMESPACE_PREFIX, 0); }
		public TerminalNode KW_NATIVE() { return getToken(SyntaxParser.KW_NATIVE, 0); }
		public TerminalNode KW_NATIONAL() { return getToken(SyntaxParser.KW_NATIONAL, 0); }
		public TerminalNode KW_NEGATIVE() { return getToken(SyntaxParser.KW_NEGATIVE, 0); }
		public TerminalNode KW_NEW() { return getToken(SyntaxParser.KW_NEW, 0); }
		public TerminalNode KW_NEXT() { return getToken(SyntaxParser.KW_NEXT, 0); }
		public TerminalNode KW_NO() { return getToken(SyntaxParser.KW_NO, 0); }
		public TerminalNode KW_NOT() { return getToken(SyntaxParser.KW_NOT, 0); }
		public TerminalNode KW_NUMERIC() { return getToken(SyntaxParser.KW_NUMERIC, 0); }
		public TerminalNode KW_NONNUMERIC() { return getToken(SyntaxParser.KW_NONNUMERIC, 0); }
		public TerminalNode KW_NULL() { return getToken(SyntaxParser.KW_NULL, 0); }
		public TerminalNode KW_NULLS() { return getToken(SyntaxParser.KW_NULLS, 0); }
		public TerminalNode KW_OBJECT() { return getToken(SyntaxParser.KW_OBJECT, 0); }
		public TerminalNode KW_OBJECT_COMPUTER() { return getToken(SyntaxParser.KW_OBJECT_COMPUTER, 0); }
		public TerminalNode KW_OCCURS() { return getToken(SyntaxParser.KW_OCCURS, 0); }
		public TerminalNode KW_OUTPUT() { return getToken(SyntaxParser.KW_OUTPUT, 0); }
		public TerminalNode KW_OF() { return getToken(SyntaxParser.KW_OF, 0); }
		public TerminalNode KW_OFF() { return getToken(SyntaxParser.KW_OFF, 0); }
		public TerminalNode KW_ON() { return getToken(SyntaxParser.KW_ON, 0); }
		public TerminalNode KW_OMITTED() { return getToken(SyntaxParser.KW_OMITTED, 0); }
		public TerminalNode KW_OPEN() { return getToken(SyntaxParser.KW_OPEN, 0); }
		public TerminalNode KW_OR() { return getToken(SyntaxParser.KW_OR, 0); }
		public TerminalNode KW_ORDER() { return getToken(SyntaxParser.KW_ORDER, 0); }
		public TerminalNode KW_ORGANIZATION() { return getToken(SyntaxParser.KW_ORGANIZATION, 0); }
		public TerminalNode KW_OPTIONAL() { return getToken(SyntaxParser.KW_OPTIONAL, 0); }
		public TerminalNode KW_OTHER() { return getToken(SyntaxParser.KW_OTHER, 0); }
		public TerminalNode KW_OVERFLOW() { return getToken(SyntaxParser.KW_OVERFLOW, 0); }
		public TerminalNode KW_PACKED_DECIMAL() { return getToken(SyntaxParser.KW_PACKED_DECIMAL, 0); }
		public TerminalNode KW_PADDING() { return getToken(SyntaxParser.KW_PADDING, 0); }
		public TerminalNode KW_PAGE() { return getToken(SyntaxParser.KW_PAGE, 0); }
		public TerminalNode KW_PARAGRAPH() { return getToken(SyntaxParser.KW_PARAGRAPH, 0); }
		public TerminalNode KW_PARSE() { return getToken(SyntaxParser.KW_PARSE, 0); }
		public TerminalNode KW_PASSWORD() { return getToken(SyntaxParser.KW_PASSWORD, 0); }
		public TerminalNode KW_PERFORM() { return getToken(SyntaxParser.KW_PERFORM, 0); }
		public TerminalNode KW_PIC() { return getToken(SyntaxParser.KW_PIC, 0); }
		public TerminalNode KW_PICTURE() { return getToken(SyntaxParser.KW_PICTURE, 0); }
		public TerminalNode KW_POINTER() { return getToken(SyntaxParser.KW_POINTER, 0); }
		public TerminalNode KW_POINTER_32() { return getToken(SyntaxParser.KW_POINTER_32, 0); }
		public TerminalNode KW_POSITION() { return getToken(SyntaxParser.KW_POSITION, 0); }
		public TerminalNode KW_POSITIVE() { return getToken(SyntaxParser.KW_POSITIVE, 0); }
		public TerminalNode KW_PROCEDURE() { return getToken(SyntaxParser.KW_PROCEDURE, 0); }
		public TerminalNode KW_PROCEDURE_POINTER() { return getToken(SyntaxParser.KW_PROCEDURE_POINTER, 0); }
		public TerminalNode KW_PROCEDURES() { return getToken(SyntaxParser.KW_PROCEDURES, 0); }
		public TerminalNode KW_PROCEED() { return getToken(SyntaxParser.KW_PROCEED, 0); }
		public TerminalNode KW_PROCESSING() { return getToken(SyntaxParser.KW_PROCESSING, 0); }
		public TerminalNode KW_PROGRAM() { return getToken(SyntaxParser.KW_PROGRAM, 0); }
		public TerminalNode KW_PROGRAM_ID() { return getToken(SyntaxParser.KW_PROGRAM_ID, 0); }
		public TerminalNode KW_RANDOM() { return getToken(SyntaxParser.KW_RANDOM, 0); }
		public TerminalNode KW_READ() { return getToken(SyntaxParser.KW_READ, 0); }
		public TerminalNode KW_RECORD() { return getToken(SyntaxParser.KW_RECORD, 0); }
		public TerminalNode KW_RECORDING() { return getToken(SyntaxParser.KW_RECORDING, 0); }
		public TerminalNode KW_RECORDS() { return getToken(SyntaxParser.KW_RECORDS, 0); }
		public TerminalNode KW_RECURSIVE() { return getToken(SyntaxParser.KW_RECURSIVE, 0); }
		public TerminalNode KW_REDEFINES() { return getToken(SyntaxParser.KW_REDEFINES, 0); }
		public TerminalNode KW_REEL() { return getToken(SyntaxParser.KW_REEL, 0); }
		public TerminalNode KW_REFERENCE() { return getToken(SyntaxParser.KW_REFERENCE, 0); }
		public TerminalNode KW_RELATIVE() { return getToken(SyntaxParser.KW_RELATIVE, 0); }
		public TerminalNode KW_RELEASE() { return getToken(SyntaxParser.KW_RELEASE, 0); }
		public TerminalNode KW_REMAINDER() { return getToken(SyntaxParser.KW_REMAINDER, 0); }
		public TerminalNode KW_REMOVAL() { return getToken(SyntaxParser.KW_REMOVAL, 0); }
		public TerminalNode KW_RENAMES() { return getToken(SyntaxParser.KW_RENAMES, 0); }
		public TerminalNode KW_RERUN() { return getToken(SyntaxParser.KW_RERUN, 0); }
		public TerminalNode KW_RETURN() { return getToken(SyntaxParser.KW_RETURN, 0); }
		public TerminalNode KW_REPLACING() { return getToken(SyntaxParser.KW_REPLACING, 0); }
		public TerminalNode KW_REPOSITORY() { return getToken(SyntaxParser.KW_REPOSITORY, 0); }
		public TerminalNode KW_RESERVE() { return getToken(SyntaxParser.KW_RESERVE, 0); }
		public TerminalNode KW_RETURNING() { return getToken(SyntaxParser.KW_RETURNING, 0); }
		public TerminalNode KW_REVERSED() { return getToken(SyntaxParser.KW_REVERSED, 0); }
		public TerminalNode KW_REWIND() { return getToken(SyntaxParser.KW_REWIND, 0); }
		public TerminalNode KW_REWRITE() { return getToken(SyntaxParser.KW_REWRITE, 0); }
		public TerminalNode KW_RIGHT() { return getToken(SyntaxParser.KW_RIGHT, 0); }
		public TerminalNode KW_ROUNDED() { return getToken(SyntaxParser.KW_ROUNDED, 0); }
		public TerminalNode KW_RUN() { return getToken(SyntaxParser.KW_RUN, 0); }
		public TerminalNode KW_SD() { return getToken(SyntaxParser.KW_SD, 0); }
		public TerminalNode KW_SAME() { return getToken(SyntaxParser.KW_SAME, 0); }
		public TerminalNode KW_SEARCH() { return getToken(SyntaxParser.KW_SEARCH, 0); }
		public TerminalNode KW_SECTION() { return getToken(SyntaxParser.KW_SECTION, 0); }
		public TerminalNode KW_SEGMENT_LIMIT() { return getToken(SyntaxParser.KW_SEGMENT_LIMIT, 0); }
		public TerminalNode KW_SELECT() { return getToken(SyntaxParser.KW_SELECT, 0); }
		public TerminalNode KW_SELF() { return getToken(SyntaxParser.KW_SELF, 0); }
		public TerminalNode KW_SENTENCE() { return getToken(SyntaxParser.KW_SENTENCE, 0); }
		public TerminalNode KW_SEPARATE() { return getToken(SyntaxParser.KW_SEPARATE, 0); }
		public TerminalNode KW_SEQUENCE() { return getToken(SyntaxParser.KW_SEQUENCE, 0); }
		public TerminalNode KW_SEQUENTIAL() { return getToken(SyntaxParser.KW_SEQUENTIAL, 0); }
		public TerminalNode KW_SET() { return getToken(SyntaxParser.KW_SET, 0); }
		public TerminalNode KW_SIGN() { return getToken(SyntaxParser.KW_SIGN, 0); }
		public TerminalNode KW_SIZE() { return getToken(SyntaxParser.KW_SIZE, 0); }
		public TerminalNode KW_SORT() { return getToken(SyntaxParser.KW_SORT, 0); }
		public TerminalNode KW_SORT_MERGE() { return getToken(SyntaxParser.KW_SORT_MERGE, 0); }
		public TerminalNode KW_SOURCE_COMPUTER() { return getToken(SyntaxParser.KW_SOURCE_COMPUTER, 0); }
		public TerminalNode KW_SPACE() { return getToken(SyntaxParser.KW_SPACE, 0); }
		public TerminalNode KW_SPACES() { return getToken(SyntaxParser.KW_SPACES, 0); }
		public TerminalNode KW_SPECIAL_NAMES() { return getToken(SyntaxParser.KW_SPECIAL_NAMES, 0); }
		public TerminalNode KW_SQL() { return getToken(SyntaxParser.KW_SQL, 0); }
		public TerminalNode KW_SQLIMS() { return getToken(SyntaxParser.KW_SQLIMS, 0); }
		public TerminalNode KW_STANDARD() { return getToken(SyntaxParser.KW_STANDARD, 0); }
		public TerminalNode KW_STANDARD_1() { return getToken(SyntaxParser.KW_STANDARD_1, 0); }
		public TerminalNode KW_STANDARD_2() { return getToken(SyntaxParser.KW_STANDARD_2, 0); }
		public TerminalNode KW_START() { return getToken(SyntaxParser.KW_START, 0); }
		public TerminalNode KW_STATUS() { return getToken(SyntaxParser.KW_STATUS, 0); }
		public TerminalNode KW_STOP() { return getToken(SyntaxParser.KW_STOP, 0); }
		public TerminalNode KW_STRING() { return getToken(SyntaxParser.KW_STRING, 0); }
		public TerminalNode KW_SUBTRACT() { return getToken(SyntaxParser.KW_SUBTRACT, 0); }
		public TerminalNode KW_SUPER() { return getToken(SyntaxParser.KW_SUPER, 0); }
		public TerminalNode KW_SUPPRESS() { return getToken(SyntaxParser.KW_SUPPRESS, 0); }
		public TerminalNode KW_SYMBOL() { return getToken(SyntaxParser.KW_SYMBOL, 0); }
		public TerminalNode KW_SYMBOLIC() { return getToken(SyntaxParser.KW_SYMBOLIC, 0); }
		public TerminalNode KW_SYNC() { return getToken(SyntaxParser.KW_SYNC, 0); }
		public TerminalNode KW_SYNCHRONIZED() { return getToken(SyntaxParser.KW_SYNCHRONIZED, 0); }
		public TerminalNode KW_TALLYING() { return getToken(SyntaxParser.KW_TALLYING, 0); }
		public TerminalNode KW_TAPE() { return getToken(SyntaxParser.KW_TAPE, 0); }
		public TerminalNode KW_TEST() { return getToken(SyntaxParser.KW_TEST, 0); }
		public TerminalNode KW_THAN() { return getToken(SyntaxParser.KW_THAN, 0); }
		public TerminalNode KW_THEN() { return getToken(SyntaxParser.KW_THEN, 0); }
		public TerminalNode KW_THROUGH() { return getToken(SyntaxParser.KW_THROUGH, 0); }
		public TerminalNode KW_THRU() { return getToken(SyntaxParser.KW_THRU, 0); }
		public TerminalNode KW_TIME() { return getToken(SyntaxParser.KW_TIME, 0); }
		public TerminalNode KW_TIMES() { return getToken(SyntaxParser.KW_TIMES, 0); }
		public TerminalNode KW_TO() { return getToken(SyntaxParser.KW_TO, 0); }
		public TerminalNode KW_TOP() { return getToken(SyntaxParser.KW_TOP, 0); }
		public TerminalNode KW_TRAILING() { return getToken(SyntaxParser.KW_TRAILING, 0); }
		public TerminalNode KW_TRUE() { return getToken(SyntaxParser.KW_TRUE, 0); }
		public TerminalNode KW_TYPE() { return getToken(SyntaxParser.KW_TYPE, 0); }
		public TerminalNode KW_UNIT() { return getToken(SyntaxParser.KW_UNIT, 0); }
		public TerminalNode KW_UNBOUNDED() { return getToken(SyntaxParser.KW_UNBOUNDED, 0); }
		public TerminalNode KW_UNTIL() { return getToken(SyntaxParser.KW_UNTIL, 0); }
		public TerminalNode KW_UNSTRING() { return getToken(SyntaxParser.KW_UNSTRING, 0); }
		public TerminalNode KW_UP() { return getToken(SyntaxParser.KW_UP, 0); }
		public TerminalNode KW_UPON() { return getToken(SyntaxParser.KW_UPON, 0); }
		public TerminalNode KW_USAGE() { return getToken(SyntaxParser.KW_USAGE, 0); }
		public TerminalNode KW_USE() { return getToken(SyntaxParser.KW_USE, 0); }
		public TerminalNode KW_USING() { return getToken(SyntaxParser.KW_USING, 0); }
		public TerminalNode KW_UTF_8() { return getToken(SyntaxParser.KW_UTF_8, 0); }
		public TerminalNode KW_VALIDATING() { return getToken(SyntaxParser.KW_VALIDATING, 0); }
		public TerminalNode KW_VALUE() { return getToken(SyntaxParser.KW_VALUE, 0); }
		public TerminalNode KW_VARYING() { return getToken(SyntaxParser.KW_VARYING, 0); }
		public TerminalNode KW_VOLATILE() { return getToken(SyntaxParser.KW_VOLATILE, 0); }
		public TerminalNode KW_WHEN() { return getToken(SyntaxParser.KW_WHEN, 0); }
		public TerminalNode KW_WITH() { return getToken(SyntaxParser.KW_WITH, 0); }
		public TerminalNode KW_WRITE() { return getToken(SyntaxParser.KW_WRITE, 0); }
		public TerminalNode KW_WRITE_ONLY() { return getToken(SyntaxParser.KW_WRITE_ONLY, 0); }
		public TerminalNode KW_WORDS() { return getToken(SyntaxParser.KW_WORDS, 0); }
		public TerminalNode KW_WORKING_STORAGE() { return getToken(SyntaxParser.KW_WORKING_STORAGE, 0); }
		public TerminalNode KW_XML() { return getToken(SyntaxParser.KW_XML, 0); }
		public TerminalNode KW_XML_SCHEMA() { return getToken(SyntaxParser.KW_XML_SCHEMA, 0); }
		public TerminalNode KW_XML_DECLARATION() { return getToken(SyntaxParser.KW_XML_DECLARATION, 0); }
		public TerminalNode KW_YYYYDDD() { return getToken(SyntaxParser.KW_YYYYDDD, 0); }
		public TerminalNode KW_YYYYMMDD() { return getToken(SyntaxParser.KW_YYYYMMDD, 0); }
		public TerminalNode KW_ZERO() { return getToken(SyntaxParser.KW_ZERO, 0); }
		public TerminalNode KW_ZEROES() { return getToken(SyntaxParser.KW_ZEROES, 0); }
		public TerminalNode KW_ZEROS() { return getToken(SyntaxParser.KW_ZEROS, 0); }
		public KeywordContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_keyword; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SyntaxParserListener ) ((SyntaxParserListener)listener).enterKeyword(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SyntaxParserListener ) ((SyntaxParserListener)listener).exitKeyword(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof SyntaxParserVisitor ) return ((SyntaxParserVisitor<? extends T>)visitor).visitKeyword(this);
			else return visitor.visitChildren(this);
		}
	}

	public final KeywordContext keyword() throws RecognitionException {
		KeywordContext _localctx = new KeywordContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_keyword);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(79);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & -2L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -1L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & -1L) != 0) || ((((_la - 192)) & ~0x3f) == 0 && ((1L << (_la - 192)) & -1L) != 0) || ((((_la - 258)) & ~0x3f) == 0 && ((1L << (_la - 258)) & -1L) != 0) || ((((_la - 322)) & ~0x3f) == 0 && ((1L << (_la - 322)) & 2199006478335L) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static final String _serializedATN =
		"\u0004\u0001\u0195R\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001\u0002"+
		"\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004\u0002"+
		"\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007\u0002"+
		"\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b\u0001"+
		"\u0000\u0001\u0000\u0005\u0000\u001b\b\u0000\n\u0000\f\u0000\u001e\t\u0000"+
		"\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001\u0001\u0003\u0001"+
		"%\b\u0001\u0001\u0001\u0001\u0001\u0003\u0001)\b\u0001\u0001\u0001\u0001"+
		"\u0001\u0005\u0001-\b\u0001\n\u0001\f\u00010\t\u0001\u0001\u0001\u0001"+
		"\u0001\u0001\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0001\u0004\u0001"+
		"\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0005\u0001\u0005\u0001"+
		"\u0005\u0001\u0006\u0005\u0006A\b\u0006\n\u0006\f\u0006D\t\u0006\u0001"+
		"\u0007\u0001\u0007\u0001\b\u0001\b\u0003\bJ\b\b\u0001\t\u0001\t\u0001"+
		"\n\u0001\n\u0001\u000b\u0001\u000b\u0001\u000b\u0000\u0000\f\u0000\u0002"+
		"\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016\u0000\u0005\u0001\u0000"+
		"\u00f3\u00f4\u0001\u0000\u0190\u0190\u0001\u0000\u018d\u018e\u0001\u0000"+
		"\u0188\u018c\u0003\u0000\u0001\u00ff\u0102\u0159\u015b\u016aM\u0000\u001c"+
		"\u0001\u0000\u0000\u0000\u0002!\u0001\u0000\u0000\u0000\u00043\u0001\u0000"+
		"\u0000\u0000\u00065\u0001\u0000\u0000\u0000\b7\u0001\u0000\u0000\u0000"+
		"\n<\u0001\u0000\u0000\u0000\fB\u0001\u0000\u0000\u0000\u000eE\u0001\u0000"+
		"\u0000\u0000\u0010I\u0001\u0000\u0000\u0000\u0012K\u0001\u0000\u0000\u0000"+
		"\u0014M\u0001\u0000\u0000\u0000\u0016O\u0001\u0000\u0000\u0000\u0018\u001b"+
		"\u0003\u0002\u0001\u0000\u0019\u001b\u0003\n\u0005\u0000\u001a\u0018\u0001"+
		"\u0000\u0000\u0000\u001a\u0019\u0001\u0000\u0000\u0000\u001b\u001e\u0001"+
		"\u0000\u0000\u0000\u001c\u001a\u0001\u0000\u0000\u0000\u001c\u001d\u0001"+
		"\u0000\u0000\u0000\u001d\u001f\u0001\u0000\u0000\u0000\u001e\u001c\u0001"+
		"\u0000\u0000\u0000\u001f \u0005\u0000\u0000\u0001 \u0001\u0001\u0000\u0000"+
		"\u0000!$\u0003\u0004\u0002\u0000\"%\u0003\u0006\u0003\u0000#%\u0005\u008c"+
		"\u0000\u0000$\"\u0001\u0000\u0000\u0000$#\u0001\u0000\u0000\u0000%.\u0001"+
		"\u0000\u0000\u0000&(\u0007\u0000\u0000\u0000\')\u0005\u00b1\u0000\u0000"+
		"(\'\u0001\u0000\u0000\u0000()\u0001\u0000\u0000\u0000)*\u0001\u0000\u0000"+
		"\u0000*-\u0005\u0193\u0000\u0000+-\u0003\u000e\u0007\u0000,&\u0001\u0000"+
		"\u0000\u0000,+\u0001\u0000\u0000\u0000-0\u0001\u0000\u0000\u0000.,\u0001"+
		"\u0000\u0000\u0000./\u0001\u0000\u0000\u0000/1\u0001\u0000\u0000\u0000"+
		"0.\u0001\u0000\u0000\u000012\u0005\u0190\u0000\u00002\u0003\u0001\u0000"+
		"\u0000\u000034\u0005\u018d\u0000\u00004\u0005\u0001\u0000\u0000\u0000"+
		"56\u0005\u018f\u0000\u00006\u0007\u0001\u0000\u0000\u000078\u0005\u0083"+
		"\u0000\u000089\u0003\f\u0006\u00009:\u0005j\u0000\u0000:;\u0005\u0190"+
		"\u0000\u0000;\t\u0001\u0000\u0000\u0000<=\u0003\f\u0006\u0000=>\u0005"+
		"\u0190\u0000\u0000>\u000b\u0001\u0000\u0000\u0000?A\u0003\u000e\u0007"+
		"\u0000@?\u0001\u0000\u0000\u0000AD\u0001\u0000\u0000\u0000B@\u0001\u0000"+
		"\u0000\u0000BC\u0001\u0000\u0000\u0000C\r\u0001\u0000\u0000\u0000DB\u0001"+
		"\u0000\u0000\u0000EF\b\u0001\u0000\u0000F\u000f\u0001\u0000\u0000\u0000"+
		"GJ\u0003\u0012\t\u0000HJ\u0003\u0014\n\u0000IG\u0001\u0000\u0000\u0000"+
		"IH\u0001\u0000\u0000\u0000J\u0011\u0001\u0000\u0000\u0000KL\u0007\u0002"+
		"\u0000\u0000L\u0013\u0001\u0000\u0000\u0000MN\u0007\u0003\u0000\u0000"+
		"N\u0015\u0001\u0000\u0000\u0000OP\u0007\u0004\u0000\u0000P\u0017\u0001"+
		"\u0000\u0000\u0000\b\u001a\u001c$(,.BI";
	public static final ATN _ATN =
		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
	static {
		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
		}
	}
}